Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

plugins/logging/utils.go (1)

56-86: Fix retry loop compilation error.

The retry loop uses for attempt := range maxRetries, which doesn't compile in Go—you cannot range over an int. This blocks the build.

Apply this diff:

-	for attempt := range maxRetries {
+	for attempt := 0; attempt < maxRetries; attempt++ {

ui/app/logs/views/logChatMessageView.tsx (1)

129-144: Consider using or removing the unused getRoleColor helper.

The getRoleColor function is defined but never used in the component. Line 150 renders the role title without applying the color styling that this function provides.

If role-based coloring is intended, apply the color class at line 150:

-			<span className={`inline-block rounded text-sm font-medium`}>{getRoleTitle(message.role)}</span>
+			<span className={`inline-block rounded px-2 py-1 text-sm font-medium ${getRoleColor(message.role)}`}>{getRoleTitle(message.role)}</span>

Otherwise, remove the unused helper to reduce clutter.

ui/app/logs/views/logResponsesOutputView.tsx (1)

8-27: Extract duplicated helpers to a shared utility module.

The isJson and cleanJson helpers are duplicated between this file and logChatMessageView.tsx. Extracting them to a shared utility module (e.g., utils.ts or jsonHelpers.ts) would eliminate duplication and improve maintainability.

Create a new file ui/app/logs/views/jsonHelpers.ts:

export const isJson = (text: string) => {
	try {
		JSON.parse(text);
		return true;
	} catch {
		return false;
	}
};

export const cleanJson = (text: unknown) => {
	try {
		if (typeof text === "string") return JSON.parse(text);
		if (Array.isArray(text)) return text;
		if (text !== null && typeof text === "object") return text;
		if (typeof text === "number" || typeof text === "boolean") return text;
		return "Invalid payload";
	} catch {
		return text;
	}
};

Then import in both files:

+import { isJson, cleanJson } from "./jsonHelpers";
-const isJson = (text: string) => { ... };
-const cleanJson = (text: unknown) => { ... };

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

ui/app/logs/views/logChatMessageView.tsx (1)

12-12: Replace all underscores in type label

Use a global replace so all underscores become spaces.

-<div className="bg-muted/50 text-muted-foreground px-6 py-2 text-xs font-medium capitalize">{block.type.replace("_", " ")}</div>
+<div className="bg-muted/50 text-muted-foreground px-6 py-2 text-xs font-medium capitalize">{block.type.replace(/_/g, " ")}</div>

plugins/logging/main.go (1)

396-399: Persist the served model, not the requested one.

You guard on result.Model but persist ExtraFields.ModelRequested, so logs show the requested model instead of the actual served model.

Apply this diff:

-            if result.Model != "" {
-                updateData.Model = result.ExtraFields.ModelRequested
-            }
+            if result.Model != "" {
+                updateData.Model = result.Model
+            }

framework/streaming/responses.go (2)

86-91: Ordering bug: keys assumed contiguous; sort indices.

messageMap iteration using 0..len(map)-1 drops/shuffles outputs when indices have gaps/out-of-order.

Apply this diff (and add import):

@@
-    // Convert map to ordered slice
-    for i := 0; i < len(messageMap); i++ {
-        if msg, exists := messageMap[i]; exists {
-            completeMessages = append(completeMessages, *msg)
-        }
-    }
+    // Convert map to ordered slice by sorted OutputIndex
+    keys := make([]int, 0, len(messageMap))
+    for k := range messageMap {
+        keys = append(keys, k)
+    }
+    sort.Ints(keys)
+    for _, k := range keys {
+        if msg, ok := messageMap[k]; ok {
+            completeMessages = append(completeMessages, *msg)
+        }
+    }

And at imports:

-import (
+import (
     "context"
     "fmt"
+    "sort"
     "time"

---

275-337: Remove OpenAI special-case; also fixes a compile error.

provider (schemas.ModelProvider) is compared to "openai" (string), which won’t compile; and the final-chunk assumption is incorrect. Treat all providers via accumulation.

Apply this diff:

-    // For OpenAI provider, the last chunk already contains the whole accumulated response
-    // so just return it as is
-    if provider == "openai" {
-        isFinalChunk := bifrost.IsFinalChunk(ctx)
-        if isFinalChunk {
-            ...
-            return &ProcessedStreamResponse{ ... }, nil
-        }
-        // For non-final chunks from OpenAI, just pass through
-        return &ProcessedStreamResponse{
-            Type:       StreamResponseTypeDelta,
-            RequestID:  requestID,
-            StreamType: StreamTypeResponses,
-            Provider:   provider,
-            Model:      model,
-            Data:       nil,
-        }, nil
-    }
+    // All providers use the accumulation logic; no special-casing needed

And adjust the comment below:

-    // For non-OpenAI providers, use the accumulation logic
+    // Use the accumulation logic

plugins/logging/pool.go (1)

33-46: Simplify/robustify pool reset (zero the struct)

Instead of manually clearing fields (easy to miss new ones), zero the struct before putting it back.

 func (p *LoggerPlugin) putUpdateLogData(data *UpdateLogData) {
-  // Reset all fields to avoid memory leaks
-  data.Status = ""
-  data.TokenUsage = nil
-  data.ChatOutput = nil
-  data.ResponsesOutput = nil
-  data.ErrorDetails = nil
-  data.Model = ""
-  data.Object = ""
-  data.SpeechOutput = nil
-  data.TranscriptionOutput = nil
-  data.EmbeddingOutput = nil
-  data.Cost = nil
+  // Reset all fields to avoid memory leaks (future-proof)
+  *data = UpdateLogData{}
   p.updateDataPool.Put(data)
 }

ui/lib/utils/validation.ts (2)

467-475: Avoid duplicate JSON-validators; alias to existing isValidJSON

This duplicates isValidJSON above. Alias instead to keep behavior in one place.

-export const isJson = (text: string) => {
-  try {
-    JSON.parse(text);
-    return true;
-  } catch {
-    return false;
-  }
-};
+export const isJson = (text: string) => isValidJSON(text);

---

477-487: cleanJson is fine; consider keeping behavior centralized

No issues. If you later extend parsing rules, keep it alongside isValidJSON for consistency.

ui/app/logs/views/logDetailsSheet.tsx (4)

119-121: Preserve zero token counts (use ?? not ||)

Current || "-" hides 0 as “-”. Use nullish coalescing.

-<LogEntryDetailsView className="w-full" label="Prompt Tokens" value={log.token_usage?.prompt_tokens || "-"} />
-<LogEntryDetailsView className="w-full" label="Completion Tokens" value={log.token_usage?.completion_tokens || "-"} />
-<LogEntryDetailsView className="w-full" label="Total Tokens" value={log.token_usage?.total_tokens || "-"} />
+<LogEntryDetailsView className="w-full" label="Prompt Tokens" value={log.token_usage?.prompt_tokens ?? "-"} />
+<LogEntryDetailsView className="w-full" label="Completion Tokens" value={log.token_usage?.completion_tokens ?? "-"} />
+<LogEntryDetailsView className="w-full" label="Total Tokens" value={log.token_usage?.total_tokens ?? "-"} />

---

161-170: Also preserve zeros in cache debug fields

threshold can be 0; || "-" will hide it. Prefer ??.

-<LogEntryDetailsView className="w-full" label="Threshold" value={log.cache_debug.threshold || "-"} />
+<LogEntryDetailsView className="w-full" label="Threshold" value={log.cache_debug.threshold ?? "-"} />

---

261-276: Avoid double “Response” sections (prefer responses_output when present)

If both output_message and responses_output exist, you render both. Prefer responses_output; fall back to output_message otherwise.

-{log.output_message && !log.error_details?.error.message && (
-  <>
-    <div className="mt-4 flex w-full items-center gap-2">
-      <div className="text-sm font-medium">Response</div>
-    </div>
-    <LogChatMessageView message={log.output_message} />
-  </>
-)}
-{log.responses_output && log.responses_output.length > 0 && !log.error_details?.error.message && (
+{log.responses_output && log.responses_output.length > 0 && !log.error_details?.error.message ? (
   <>
     <div className="mt-4 w-full text-left text-sm font-medium">Response</div>
     <LogResponsesOutputView messages={log.responses_output} />
   </>
-)}
+)
+: (log.output_message && !log.error_details?.error.message && (
+  <>
+    <div className="mt-4 flex w-full items-center gap-2">
+      <div className="text-sm font-medium">Response</div>
+    </div>
+    <LogChatMessageView message={log.output_message} />
+  </>
+))}

---

35-40: Remove unused variable toolChoice

Computed but never used.

-let toolChoice = null;
-if (log.params?.tool_choice) {
-  try {
-    toolChoice = JSON.stringify(log.params.tool_choice, null, 2);
-  } catch (ignored) {}
-}
+// tool_choice present but not displayed; remove until needed

framework/streaming/types.go (1)

167-173: Remove redundant ExtraFields assignment

You set CacheDebug, then immediately overwrite ExtraFields. Keep a single assignment.

- if p.Data.CacheDebug != nil {
-   resp.ExtraFields.CacheDebug = p.Data.CacheDebug
- }
 resp.ExtraFields = schemas.BifrostResponseExtraFields{
   CacheDebug: p.Data.CacheDebug,
   Provider:   p.Provider,
 }

ui/app/logs/views/logResponsesOutputView.tsx (1)

33-33: Always show block header for consistency

Currently hidden when text exists; show it to keep sections uniform.

-{!block.text && <div className="bg-muted/50 text-muted-foreground px-6 py-2 text-xs font-medium">{getBlockTitle(block.type)}</div>}
+<div className="bg-muted/50 text-muted-foreground px-6 py-2 text-xs font-medium">{getBlockTitle(block.type)}</div>

framework/streaming/accumulator.go (1)

346-357: Use helper put-methods to zero fields before returning to pools.

Direct pool.Put skips zeroing and can retain large references. Call the helper methods instead.

Apply this diff:

-        for _, chunk := range accumulator.ChatStreamChunks {
-            a.chatStreamChunkPool.Put(chunk)
-        }
+        for _, chunk := range accumulator.ChatStreamChunks {
+            a.putChatStreamChunk(chunk)
+        }
-        for _, chunk := range accumulator.ResponsesStreamChunks {
-            a.responsesStreamChunkPool.Put(chunk)
-        }
+        for _, chunk := range accumulator.ResponsesStreamChunks {
+            a.putResponsesStreamChunk(chunk)
+        }
-        for _, chunk := range accumulator.TranscriptionStreamChunks {
-            a.transcriptionStreamChunkPool.Put(chunk)
-        }
+        for _, chunk := range accumulator.TranscriptionStreamChunks {
+            a.putTranscriptionStreamChunk(chunk)
+        }
-        for _, chunk := range accumulator.AudioStreamChunks {
-            a.audioStreamChunkPool.Put(chunk)
-        }
+        for _, chunk := range accumulator.AudioStreamChunks {
+            a.putAudioStreamChunk(chunk)
+        }

framework/streaming/responses.go (1)

176-182: Avoid nested defer; clean up after unlock directly.

Current nested defer is confusing and contrary to the comment. Unlock first, then cleanup when final.

Apply this diff:

-    defer func() {
-        accumulator.mu.Unlock()
-        if isFinalChunk {
-            // Before unlocking, we cleanup
-            defer a.cleanupStreamAccumulator(requestID)
-        }
-    }()
+    defer func() {
+        accumulator.mu.Unlock()
+        if isFinalChunk {
+            a.cleanupStreamAccumulator(requestID)
+        }
+    }()

ui/lib/types/logs.ts (1)

305-544: Consider strengthening type safety and adding documentation.

The comprehensive Responses API type definitions are well-structured, but several areas could benefit from improved type safety:

1. Index signatures with any (lines 390, 419, 491): [key: string]: any disables type checking for additional properties. Consider using more specific types or union types for known properties, reserving index signatures for truly dynamic data.

2. Record<string, any> usage (lines 510, 433): This weakens type safety. If the structure is known, define explicit interfaces. If it's genuinely dynamic, document why.

3. Missing documentation: Consider adding JSDoc comments for complex types like ResponsesMessage, ResponsesMessageContentBlock, and ResponsesTool to explain their purpose, usage patterns, and when different optional fields are present.

4. Type discriminants: ResponsesMessage has many optional fields whose presence depends on the type field. Consider using discriminated unions to ensure type safety:

type ResponsesMessage = 
  | { type: "message"; role: ResponsesMessageRoleType; content: ResponsesMessageContent; /* ... */ }
  | { type: "function_call"; call_id: string; name: string; arguments: string; /* ... */ }
  | { type: "reasoning"; summary: ResponsesReasoningContent[]; /* ... */ }
  // ... other variants

This would enable better type narrowing and catch missing required fields at compile time.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

plugins/logging/utils.go (1)

61-83: Range-over-int requires Go ≥1.22; confirm toolchain

The loop is fine in Go 1.22+; earlier Go versions won’t compile this.

Please confirm CI/go.mod uses Go ≥1.22. If compatibility is needed, switch to a classic loop:

-	for attempt := range maxRetries {
+	for attempt := 0; attempt < maxRetries; attempt++ {

plugins/logging/pool.go (1)

20-23: Clear StreamResponse and fix outdated comment

Avoid retaining references when returning to pool; update comment to reflect actual fields.

-	// Don't reset UpdateData and StreamUpdateData here since they're returned
-	// to their own pools in the defer function - just clear the pointers
-	msg.UpdateData = nil
+	// Don't reset UpdateData buffers here (they're returned to their own pool).
+	// Just clear pointers on the pooled message.
+	msg.UpdateData = nil
+	msg.StreamResponse = nil

ui/app/logs/views/logChatMessageView.tsx (1)

12-12: Global underscore replacement needed (repeat from prior review).

Use a global replace so all underscores are converted to spaces.

-            <div className="bg-muted/50 text-muted-foreground px-6 py-2 text-xs font-medium capitalize">{block.type.replace("_", " ")}</div>
+            <div className="bg-muted/50 text-muted-foreground px-6 py-2 text-xs font-medium capitalize">{block.type.replace(/_/g, " ")}</div>

framework/streaming/responses.go (3)

35-53: Content parts must be placed by index, not appended.

The code appends content parts without respecting ContentIndex, which can reorder parts when chunks arrive out of order. This issue was previously flagged and remains unresolved.

Apply the previously suggested diff to fix this ordering issue by using ContentIndex to place parts at the correct position instead of appending.

---

86-91: Ordering logic can drop or shuffle outputs.

The loop assumes messageMap has contiguous keys from 0 to N-1, but if the provider skips indices or sends them out of order, this will miss entries or reorder them. This issue was previously flagged and remains unresolved.

Collect all keys from messageMap, sort them numerically, then iterate the sorted keys to preserve the exact sequence provided by the stream.

---

277-336: OpenAI final-chunk handling may be incorrect.

The code assumes the final chunk contains the complete response at result.ResponsesStreamResponse.Response.ResponsesResponse.Output, but according to a previous review, OpenAI's final chunks typically only contain usage with empty choices. The message content must be assembled from earlier chunks. This critical issue was previously flagged and remains unresolved.

Assemble the response from accumulated chunks rather than extracting it from the final chunk, and merge the final chunk's usage/cost info into the assembled data.

plugins/logging/main.go (1)

395-396: Wrong model persisted (requested vs. served).

The code checks result.Model but persists ExtraFields.ModelRequested, causing logs to show the requested model instead of the actual served model. This is inconsistent with the streaming path. This issue was previously flagged and remains unresolved.

Apply this diff:

 			if result.Model != "" {
-				updateData.Model = result.ExtraFields.ModelRequested
+				updateData.Model = result.Model
 			}

plugins/logging/operations.go (1)

44-45: Latency type mismatch with DB column.

The latency parameter is int64, but the DB column Log.Latency is *float64. Assigning int64 directly without conversion can cause driver/type issues. This was previously flagged and remains unresolved.

Apply this diff:

 	if latency != 0 {
-		updates["latency"] = latency
+		updates["latency"] = float64(latency)
 	}

Also apply similar conversions at lines 163 and 174 where streamResponse.Data.Latency is assigned.

ui/lib/types/logs.ts (1)

119-119: Clarify or remove misleading tool_calls comment.

The comment states "tool calls are now in the content," but neither ContentBlock nor ResponsesMessageContentBlock includes a field for tool calls. This was previously flagged and remains misleading.

Either remove the comment or update it to clarify that tool_calls is kept for backward compatibility but is not surfaced in the content structures.

plugins/logging/utils.go (2)

88-92: Guard against nil BifrostRequest to avoid panic

Add a quick nil check to make this helper safe.

 func (p *LoggerPlugin) extractInputHistory(request *schemas.BifrostRequest) []schemas.ChatMessage {
+	if request == nil {
+		return []schemas.ChatMessage{}
+	}

---

104-109: Preserve prompt boundaries when concatenating PromptArray

Current concat omits separators; join with newline (or space) for readability.

-			var stringBuilder strings.Builder
-			for _, prompt := range request.TextCompletionRequest.Input.PromptArray {
-				stringBuilder.WriteString(prompt)
-			}
-			text = stringBuilder.String()
+			text = strings.Join(request.TextCompletionRequest.
+				Input.PromptArray, "\n")

transports/bifrost-http/handlers/inference.go (2)

598-607: Remove duplicate initialization of SpeechParameters

This block is repeated immediately below. Keep only one.

-	// Extract extra params
-	if req.SpeechParameters == nil {
-		req.SpeechParameters = &schemas.SpeechParameters{}
-	}

---

44-62: Use “prompt” (not “text”) in known fields for text completion

Your TextRequest uses prompt; keeping “text” marks prompt as extra.

 var textParamsKnownFields = map[string]bool{
 	"model":             true,
-	"text":              true,
+	"prompt":            true,
 	"fallbacks":         true,
 	"best_of":           true,
 	"echo":              true,

ui/lib/constants/logs.ts (2)

95-95: Label “list” as “Embedding” for consistency

Legacy “list” represents embeddings; align the label to reduce confusion.

-	list: "List",
+	list: "Embedding",

---

26-52: Add a RequestType type and enforce map keys

Strengthen type-safety to catch missing/extra request-type keys.

 // TODO: Remove dependency on old request types (object field in bifrost) by applying migrations to the database
 export const RequestTypes = [
@@
 ] as const;
+
+export type RequestType = (typeof RequestTypes)[number];

Apply outside selected ranges:

// Enforce labels/colors to cover all RequestTypes
export const RequestTypeLabels: Record<RequestType, string> = { /* current entries */ };
export const RequestTypeColors: Record<RequestType, string> = { /* current entries */ };

framework/logstore/tables.go (2)

79-79: Comment incorrect: field stores a slice, not a single message.

Adjust the comment to reflect JSON serialized []schemas.ResponsesMessage.

-    ResponsesOutput     string    `gorm:"type:text" json:"-"` // JSON serialized *schemas.ResponsesMessage
+    ResponsesOutput     string    `gorm:"type:text" json:"-"` // JSON serialized []schemas.ResponsesMessage

---

418-441: Verify reasoning field name for ResponsesMessage in summary extraction.

Code uses msg.ResponsesReasoning.Summary; confirm the actual struct field (likely msg.Reasoning.Summary). If mismatched, reasoning text won’t be indexed.

If the field is Reasoning, apply:

-    if msg.ResponsesReasoning != nil {
-        for _, summary := range msg.ResponsesReasoning.Summary {
+    if msg.Reasoning != nil {
+        for _, summary := range msg.Reasoning.Summary {
             parts = append(parts, summary.Text)
         }
     }

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

framework/streaming/responses.go (3)

86-91: Don’t assume contiguous indices; sort keys before assembling.

Using len(messageMap) assumes 0..N-1 keys and can drop/shuffle outputs. Gather keys and sort.

-    for i := 0; i < len(messageMap); i++ {
-        if msg, exists := messageMap[i]; exists {
-            completeMessages = append(completeMessages, *msg)
-        }
-    }
+    indices := make([]int, 0, len(messageMap))
+    for idx := range messageMap {
+        indices = append(indices, idx)
+    }
+    sort.Ints(indices)
+    for _, i := range indices {
+        if msg, exists := messageMap[i]; exists {
+            completeMessages = append(completeMessages, *msg)
+        }
+    }

Note: add import "sort".

---

35-53: Place parts by content_index; appending can reorder.

If parts arrive out-of-order, append breaks intended order. Use content_index.

-                if messageMap[*streamResp.OutputIndex].Content.ContentBlocks == nil {
-                    messageMap[*streamResp.OutputIndex].Content.ContentBlocks = make([]schemas.ResponsesMessageContentBlock, 0)
-                }
-                messageMap[*streamResp.OutputIndex].Content.ContentBlocks = append(
-                    messageMap[*streamResp.OutputIndex].Content.ContentBlocks,
-                    *streamResp.Part,
-                )
+                blocks := messageMap[*streamResp.OutputIndex].Content.ContentBlocks
+                for len(blocks) <= *streamResp.ContentIndex {
+                    blocks = append(blocks, schemas.ResponsesMessageContentBlock{})
+                }
+                blocks[*streamResp.ContentIndex] = *streamResp.Part
+                messageMap[*streamResp.OutputIndex].Content.ContentBlocks = blocks

---

275-337: Remove OpenAI final-chunk special-casing; accumulate like others.

Final OpenAI chunks often carry usage-only with empty content; assuming they contain the full output is incorrect. Use the same accumulation path and merge final usage/cost.

-    // For OpenAI provider, the last chunk already contains the whole accumulated response
-    // so just return it as is
-    if provider == "openai" {
-        isFinalChunk := bifrost.IsFinalChunk(ctx)
-        if isFinalChunk {
-            // ... builds Data from final chunk only ...
-            return &ProcessedStreamResponse{ Type: StreamResponseTypeFinal, RequestID: requestID, StreamType: StreamTypeResponses, Provider: provider, Model: model, Data: data }, nil
-        }
-        // For non-final chunks from OpenAI, just pass through
-        return &ProcessedStreamResponse{ Type: StreamResponseTypeDelta, RequestID: requestID, StreamType: StreamTypeResponses, Provider: provider, Model: model, Data: nil }, nil
-    }
+    // Treat OpenAI like other providers: accumulate all chunks; final chunk typically contains usage.

ui/app/logs/views/logResponsesOutputView.tsx (2)

346-347: Prefer stable keys (use message.id when present).

Indexes as keys can cause unnecessary re-renders and mismatches. Use message.id || index.

- return <div className="space-y-4">{messages.map((message, index) => renderMessage(message, index))}</div>;
+ return <div className="space-y-4">{messages.map((message, index) => renderMessage(message, message.id ?? index))}</div>;

---

305-321: Deduplicate the exclusion list for “Additional Fields”.

The hard-coded list appears twice; extract a shared constant to prevent drift and simplify maintenance.

framework/streaming/responses.go (1)

176-182: Avoid nested defer; call cleanup directly after unlock.

Nested defer inside a deferred func is confusing with no benefit. Simplify.

-    defer func() {
-        accumulator.mu.Unlock()
-        if isFinalChunk {
-            // Before unlocking, we cleanup
-            defer a.cleanupStreamAccumulator(requestID)
-        }
-    }()
+    defer func() {
+        accumulator.mu.Unlock()
+        if isFinalChunk {
+            a.cleanupStreamAccumulator(requestID)
+        }
+    }()

ui/lib/types/logs.ts (2)

385-391: Consider strengthening type safety for extensible interfaces.

The [key: string]: any index signature in ResponsesToolMessage (line 390) and ResponsesMessage (line 419) allows arbitrary properties without type checking, reducing TypeScript's safety guarantees. If tool-specific or message-specific properties are known, prefer explicit optional fields or a discriminated union keyed by type.

If the property set is truly open-ended and documented by the Responses API specification, consider adding a JSDoc comment explaining why the index signature is necessary and what constraints apply to the dynamic properties.

Also applies to: 405-420

---

484-492: Consider strengthening type safety for extensible tool interface.

The [key: string]: any index signature (line 491) permits arbitrary properties without type checking. If the Responses API specification defines specific tool configurations, prefer explicit optional fields or discriminated unions keyed by type.

If the property set is truly open-ended, add a JSDoc comment explaining the extensibility requirement and constraints.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

framework/streaming/responses.go (2)

414-427: Set Data.Model for delta responses too.

Same issue as the final chunk path: model is extracted but not assigned to data.Model.

Apply this diff:

     data, processErr := a.processAccumulatedResponsesStreamingChunks(requestID, bifrostErr, isFinalChunk)
     if processErr != nil {
         a.logger.Error("failed to process accumulated responses chunks for request %s: %v", requestID, processErr)
         return nil, processErr
     }
+    data.Model = model

     return &ProcessedStreamResponse{
         Type:       StreamResponseTypeDelta,

---

395-408: Set Data.Model for logging persistence.

The model variable is extracted (line 273) but never assigned to data.Model before returning. Without this, the logging plugin cannot persist the model for responses streams, as updateStreamingLogEntry reads streamResponse.Data.Model (plugins/logging/operations.go:177).

Apply this diff:

         data, processErr := a.processAccumulatedResponsesStreamingChunks(requestID, bifrostErr, isFinalChunk)
         if processErr != nil {
             a.logger.Error("failed to process accumulated responses chunks for request %s: %v", requestID, processErr)
             return nil, processErr
         }
+        data.Model = model

         return &ProcessedStreamResponse{
             Type:       StreamResponseTypeFinal,

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

ui/lib/types/logs.ts (1)

495-499: Use JSDoc @deprecated tag for better tooling support.

The generate_summary field uses an inline // Deprecated comment. TypeScript tooling provides better support (IDE warnings, strikethrough, etc.) when using JSDoc annotations.

Apply this diff:

 export interface ResponsesParametersReasoning {
 	effort?: "minimal" | "low" | "medium" | "high";
+	/**
+	 * @deprecated Use `summary` instead
+	 */
-	generate_summary?: string; // Deprecated
+	generate_summary?: string;
 	summary?: "auto" | "concise" | "detailed";
 }

core/schemas/mux.go (1)

910-915: Set ContentIndex per delta; avoid setting it at item-added initialization

Initializing ContentIndex at item-added is misleading. Assign it where deltas occur (text/thought/refusal/args) instead.

Apply this diff:

 streamResp := &ResponsesStreamResponse{
   SequenceNumber: br.ExtraFields.ChunkIndex,
-  ContentIndex:   Ptr(0),
   OutputIndex:    &choice.Index,
 }
@@
 case delta.Content != nil && *delta.Content != "":
   if delta.Content != nil && *delta.Content != "" { // Need this check again because of the fallthrough
     // Text content delta
     streamResp.Type = ResponsesStreamResponseTypeOutputTextDelta
     streamResp.Delta = delta.Content
+    streamResp.ContentIndex = Ptr(0)
   }
@@
 case delta.Thought != nil && *delta.Thought != "":
   // Reasoning/thought content delta (for models that support reasoning)
   streamResp.Type = ResponsesStreamResponseTypeReasoningSummaryTextDelta
   streamResp.Delta = delta.Thought
+  streamResp.ContentIndex = Ptr(0)

Optionally add similar assignment in the refusal delta branch.

Also applies to: 931-936, 938-947

plugins/logging/utils.go (1)

100-109: Preserve prompt boundaries for text completions

Join PromptArray with a separator to avoid concatenation artifacts.

Apply this diff:

- var stringBuilder strings.Builder
- for _, prompt := range request.TextCompletionRequest.Input.PromptArray {
-   stringBuilder.WriteString(prompt)
- }
- text = stringBuilder.String()
+ text = strings.Join(request.TextCompletionRequest.Input.PromptArray, "\n")

framework/logstore/tables.go (1)

286-291: Consider consistency in deserialization error handling.

When deserialization fails, ResponsesOutputParsed is initialized to an empty slice []schemas.ResponsesMessage{} (line 289), while OutputMessageParsed is set to nil (line 282) and EmbeddingOutputParsed is set to nil (line 296).

For consistency, consider initializing all failed deserializations the same way (either all nil or all empty collections). The current mix could lead to subtle bugs if code assumes consistent nil-vs-empty behavior.

ui/app/logs/views/logResponsesOutputView.tsx (3)

305-322: Extract excluded keys to a constant.

The list of excluded keys is hardcoded in two places (lines 306 and 319). Extract this to a constant at the top of the file to ensure consistency and ease maintenance.

Add this constant near the top of the file (after imports):

const CORE_MESSAGE_KEYS = ["id", "type", "status", "role", "content", "call_id", "name", "arguments", "summary", "encrypted_content"] as const;

Then update both filter calls to use this constant:

-		(key) => !["id", "type", "status", "role", "content", "call_id", "name", "arguments", "summary", "encrypted_content"].includes(key),
+		(key) => !CORE_MESSAGE_KEYS.includes(key as typeof CORE_MESSAGE_KEYS[number]),

---

206-206: Remove or uncomment the status display.

The commented-out status display should either be removed if not needed or uncommented if it's meant to be shown.

---

9-161: Consider extracting CodeEditor helper to reduce duplication.

Multiple CodeEditor instances throughout the component share very similar props (lines 39-48, 58-74, 81-99, 106-115, 130-139, 147-156, etc.). While the current implementation is functional, extracting a helper function or component could improve maintainability.

Example helper function:

const renderJsonEditor = (code: string, maxHeight: number = 200) => (
  <CodeEditor
    className="z-0 w-full"
    shouldAdjustInitialHeight={true}
    maxHeight={maxHeight}
    wrap={true}
    code={code}
    lang="json"
    readonly={true}
    options={{ scrollBeyondLastLine: false, collapsibleBlocks: true, lineNumbers: "off", alwaysConsumeMouseWheel: false }}
  />
);

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

framework/streaming/responses.go (2)

86-91: Ordering/indexing of output content may be incorrect.

• Map-to-slice conversion assumes contiguous 0..N-1 indices; gaps will drop/shuffle outputs.
• ContentPartAdded appends parts, ignoring content_index ordering.

Collect and sort keys before appending, and place parts by content_index rather than append.

Also applies to: 35-53

---

401-409: Model not propagated to Data; logging won’t persist served model.

updateStreamingLogEntry reads streamResponse.Data.Model, but Data.Model is never set here.

-            return &ProcessedStreamResponse{
+            data.Model = model
+            return &ProcessedStreamResponse{
                 Type:       StreamResponseTypeFinal,
                 RequestID:  requestID,
                 StreamType: StreamTypeResponses,
                 Provider:   provider,
                 Model:      model,
                 Data:       data,
             }, nil

(Also set data.Model in the OpenAI final path above after constructing data.)

ui/lib/types/logs.ts (2)

119-121: Clarify/deprecate tool_calls comment

Content types don’t surface tool calls; the current inline note is misleading. Mark the field deprecated and clarify intent.

Apply:

-	tool_calls?: ToolCall[]; // For backward compatibility, tool calls are now in the content
+	/**
+	 * @deprecated Kept for backward compatibility only; ChatMessageContent/ContentBlock do not expose tool calls.
+	 */
+	tool_calls?: ToolCall[];

---

495-499: Use @deprecated JSDoc instead of inline comment

Replace inline “// Deprecated” with a JSDoc deprecation tag for IDE/tooling support.

 export interface ResponsesParametersReasoning {
 	effort?: "minimal" | "low" | "medium" | "high";
-	generate_summary?: string; // Deprecated
+	/**
+	 * @deprecated Use `summary` instead
+	 */
+	generate_summary?: string;
 	summary?: "auto" | "concise" | "detailed";
 }

ui/app/logs/views/logResponsesOutputView.tsx (2)

279-301: Add padding wrapper around Tool Details editor (consistency)

Wrap the CodeEditor with a div having px-6 py-2 like other sections.

 				<div className="border-b last:border-b-0">
 					<div className="bg-muted/50 text-muted-foreground px-6 py-2 text-xs font-medium">Tool Details</div>
-						<CodeEditor
+						<div className="px-6 py-2">
+						<CodeEditor
 							className="z-0 w-full"
 							shouldAdjustInitialHeight={true}
 							maxHeight={200}
 							wrap={true}
 							code={JSON.stringify(
 								{
 									...(message.call_id && { call_id: message.call_id }),
 									...(message.name && { name: message.name }),
 									...(message.arguments && { arguments: isJson(message.arguments) ? cleanJson(message.arguments) : message.arguments }),
 								},
 								null,
 								2,
 							)}
 							lang="json"
 							readonly={true}
 							options={{ scrollBeyondLastLine: false, collapsibleBlocks: true, lineNumbers: "off", alwaysConsumeMouseWheel: false }}
-						/>
+						/>
+						</div>
 				</div>

---

304-331: Add padding wrapper around Additional Fields editor (consistency)

Match section spacing by adding the standard px-6 py-2 wrapper.

 				<div className="border-b last:border-b-0">
 					<div className="bg-muted/50 text-muted-foreground px-6 py-2 text-xs font-medium">Additional Fields</div>
-						<CodeEditor
+						<div className="px-6 py-2">
+						<CodeEditor
 							className="z-0 w-full"
 							shouldAdjustInitialHeight={true}
 							maxHeight={200}
 							wrap={true}
 							code={JSON.stringify(
 								Object.fromEntries(
 									Object.entries(message).filter(
 										([key]) =>
 											!["id", "type", "status", "role", "content", "call_id", "name", "arguments", "summary", "encrypted_content"].includes(
 												key,
 											),
 									),
 								),
 								null,
 								2,
 							)}
 							lang="json"
 							readonly={true}
 							options={{ scrollBeyondLastLine: false, collapsibleBlocks: true, lineNumbers: "off", alwaysConsumeMouseWheel: false }}
-						/>
+						/>
+						</div>
 				</div>

core/schemas/providers/anthropic/responses.go (1)

505-520: Handle function_call items in reverse streaming mapping

When ResponsesStreamResponseTypeOutputItemAdded carries a function_call item, mapping it to message_start loses tool-use semantics. Prefer emitting a content_block_start with tool_use and set Name/ID.

Minimal approach: branch on responsesStream.Item.Type == function_call and populate:

• streamResp.Type = AnthropicStreamEventTypeContentBlockStart
• streamResp.ContentBlock = { Type: AnthropicContentBlockTypeToolUse, Name, ID }

This aligns with how forward mapping emits tool_use starts.

core/schemas/providers/cohere/responses.go (1)

640-647: Confirm end event type for citations

StreamEventCitationEnd maps to OutputTextAnnotationAdded again. Should this be ...AnnotationDone (if defined) to mark completion?

If supported, change:

- Type: schemas.ResponsesStreamResponseTypeOutputTextAnnotationAdded,
+ Type: schemas.ResponsesStreamResponseTypeOutputTextAnnotationDone,

Please verify the exact constant name in core/schemas/responses.go.

framework/logstore/tables.go (1)

79-84: Add DB migration and update filters for new Responses entries

New columns/fields (ResponsesOutput, ResponsesOutputParsed) require schema migration, and “object” values may include “response”. Ensure:

• DB migration adds responses_output (and backfill if needed).
• UI/API filters accept the new object type so “Objects” filtering doesn’t miss Responses logs.

I can draft a GORM auto-migrate snippet or a SQL migration if you share your migration path.

Also applies to: 106-113

framework/streaming/accumulator.go (2)

228-236: Return chunks via reset helpers before pooling.

Directly pooling chunks without zeroing fields risks stale data reuse. Use the existing put* helpers.

-        for _, chunk := range acc.ResponsesStreamChunks {
-            a.responsesStreamChunkPool.Put(chunk)
-        }
+        for _, chunk := range acc.ResponsesStreamChunks {
+            a.putResponsesStreamChunk(chunk)
+        }

(Optional parity with others):

- for _, chunk := range acc.ChatStreamChunks { a.chatStreamChunkPool.Put(chunk) }
+ for _, chunk := range acc.ChatStreamChunks { a.putChatStreamChunk(chunk) }
- for _, chunk := range acc.TranscriptionStreamChunks { a.transcriptionStreamChunkPool.Put(chunk) }
+ for _, chunk := range acc.TranscriptionStreamChunks { a.putTranscriptionStreamChunk(chunk) }
- for _, chunk := range acc.AudioStreamChunks { a.audioStreamChunkPool.Put(chunk) }
+ for _, chunk := range acc.AudioStreamChunks { a.putAudioStreamChunk(chunk) }

Also applies to: 349-351

---

176-182: Avoid defer within deferred cleanup; call directly after unlock.

The inner defer executes immediately at the end of this closure—use a direct call for clarity.

-    defer func() {
-        accumulator.mu.Unlock()
-        if isFinalChunk {
-            // Before unlocking, we cleanup
-            defer a.cleanupStreamAccumulator(requestID)
-        }
-    }()
+    defer func() {
+        accumulator.mu.Unlock()
+        if isFinalChunk {
+            // Cleanup after unlocking
+            a.cleanupStreamAccumulator(requestID)
+        }
+    }()

framework/streaming/responses.go (1)

288-291: Start/End timestamps set to now (OpenAI path).

Using time.Now() here breaks latency consistency with accumulator-based paths. Prefer accumulator timestamps or propagate StartTimestamp from PreHook.

ui/lib/types/logs.ts (2)

263-266: Align status documentation with allowed values

Comment lists only "success" and "error" while Statuses includes "processing" and "cancelled". Update the doc to avoid confusion.

Apply:

-	status: string; // "success" or "error"
+	status: string; // "success" | "error" | "processing" | "cancelled"

---

305-421: Responses types: solid foundation; consider tightening a few unions

Definitions look comprehensive. Minor type hygiene ideas:

• ResponsesMessage.status and some string-typed fields (e.g., detail on content blocks) could be unions for safer usage.

If safe, narrow:

-	detail?: string; // "low" | "high" | "auto"
+	detail?: "low" | "high" | "auto";

And optionally:

-	status?: string; // "in_progress" | "completed" | "incomplete" | "interpreting" | "failed"
+	status?: "in_progress" | "completed" | "incomplete" | "interpreting" | "failed";

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro